package com.zmn.plat.business.impl.product.tariff.item;

import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

import javax.annotation.Resource;

import com.zmn.plat.services.interfaces.pilot.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.zmn.common.utils.date.DateUtil;
import com.zmn.plat.business.interfaces.brand.ratio.BrandRatioBService;
import com.zmn.plat.business.interfaces.channel.ChannelCityPriceRatioBService;
import com.zmn.plat.business.interfaces.product.tariff.item.ProductTariffGroupItemBService;
import com.zmn.plat.model.entity.product.tariff.item.ProductTariffGroupItem;
import com.zmn.plat.model.entity.product.tariff.item.ProductTariffGroupItemQuery;
import com.zmn.plat.model.vo.product.tariff.item.ProductTariffGroupItemVo;
import com.zmn.plat.services.interfaces.area.BaseAreaService;
import com.zmn.plat.services.interfaces.category.BaseCategoryAttributeEnumService;
import com.zmn.plat.services.interfaces.category.BaseCategoryService;
import com.zmn.plat.services.interfaces.channel.ChannelCityPriceRatioService;
import com.zmn.plat.services.interfaces.channel.tariff.ChannelTariffService;
import com.zmn.plat.services.interfaces.product.FicoCategoryService;
import com.zmn.plat.services.interfaces.product.ServProductRelationService;
import com.zmn.plat.services.interfaces.product.ServProductService;
import com.zmn.plat.services.interfaces.product.tariff.ProductTariffService;
import com.zmn.plat.services.interfaces.product.tariff.item.ProductTariffGroupItemService;
import com.zmn.plat.services.interfaces.product.tariff.item.city.price.ProductTariffItemCityPriceService;
import com.zmn.plat.services.interfaces.servcategory.ServCategoryService;
import com.zmn.plat.services.interfaces.service.tariff.ServiceTariffService;

/**
 * 类描述:
 *
 * @author linfeng
 * @since 2019/11/28/11:14
 */
@Service
public class ProductTariffGroupItemBServiceImpl implements ProductTariffGroupItemBService {
    private Logger logger = LoggerFactory.getLogger(ProductTariffGroupItemBServiceImpl.class);
    // 默认系数
    private final Float RESULT_RATIO = 1.0F;
    @Resource
    ProductTariffGroupItemService productFaultItemService;
    @Resource
    ProductTariffItemCityPriceService productFaultItemCityPriceService;

    // @Override
    // public FaultProductDRO getByProductIdAndCityId(Integer channelId, Integer cityId, Integer showProductId, Integer keepType) {
    // ServProduct servProduct = servProductService.findByKey(showProductId);
    // if (Objects.isNull(servProduct)) {
    // logger.error("================================产品不存在，showProductId={}", showProductId);
    // return null;
    // }
    // BeanCopier copier = BeanCopier.create(ServProduct.class, FaultProductDRO.class, false);
    // FaultProductDRO faultProductDRO = new FaultProductDRO();
    // copier.copy(servProduct, faultProductDRO, null);
    //
    // setName(faultProductDRO);
    // ServProductRelationQuery query = new ServProductRelationQuery();
    // query.setShowProductId(showProductId);
    // List<ServProductRelation> list = servProductRelationService.listByQuery(query);
    // if (CollectionUtils.isEmpty(list)) {
    // logger.error("==================前台产品未关联后台产品.......");
    // faultProductDRO.setFixedPrice(GlobalConsts.NO);
    // return faultProductDRO;
    // }
    //
    //
    // BaseArea baseArea = baseAreaService.findByKey(cityId);
    // if (baseArea == null || NumberUtil.isNullOrZero(baseArea.getParentId())) {
    // logger.error("===============================城市不存在，cityId= {},faultProductDRO={}", cityId, faultProductDRO);
    // return null;
    // }
    // // 查询该渠道当前城市是否配置了一口价或者标准价
    // List<ChannelPriceCity> channelPriceCityList = channelPriceCityService.listByChannelAndCityIdAndType(channelId,
    // baseArea.getParentId(), cityId, OnePriceConsts.ONE_PRICE);
    //
    // if (CollectionUtils.isEmpty(channelPriceCityList)) {
    // // 如果渠道没有配置，看城市是否配置了一口价
    // List<ServCityPrice> cityPriceList = servCityPriceService.listByCityIdAndType(cityId, OnePriceConsts.ONE_PRICE);
    // if (CollectionUtils.isEmpty(cityPriceList)) {
    // faultProductDRO.setFixedPrice(GlobalConsts.NO);
    // logger.info("===============================1城市未配置了一口价，cityId= {},faultProductDRO={}", cityId, faultProductDRO);
    // translateWashProduct(faultProductDRO, list, keepType, channelId, cityId);
    // return faultProductDRO;
    // }
    //
    //// ServServiceItemQuery serviceItemQuery = new ServServiceItemQuery();
    //// serviceItemQuery.setStatus(GlobalConsts.YES);
    //// serviceItemQuery.setGroupType(type);
    //// serviceItemQuery.setProductId(productId);
    //// serviceItemQuery.setStandardId(standardId);
    //// serviceItemQuery.setFixedPrice(GlobalConsts.YES);
    //// serviceItemQuery.setDefaultItem(GlobalConsts.YES);
    //// List<ServServiceItem> servServiceItemList = servServiceItemService.listByQuery(serviceItemQuery);
    //
    //// ServServiceItem servServiceItem = servServiceItemList.get(ProductDict.ZERO);
    // ServCityPrice servCityPrice = cityPriceList.get(ProductDict.ZERO);
    //
    // // 是否设置定金
    // if (Objects.equals(servCityPrice.getDepositStatus(), GlobalConsts.YES)) {
    // ServCityPriceServ servCityPriceServ = servCityPriceServService.findByRelationIdAndServCategId(servCityPrice.getRelationId(),
    // servProduct.getServCategId());
    // if (Objects.nonNull(servCityPriceServ) && NumberUtil.isPositiveInteger(servCityPrice.getDeposit())) {
    // faultProductDRO.setEarnestPrice(servCityPrice.getDeposit());
    // }
    // }
    //
    // //不支持一口价
    // if (!CollectionUtils.isEmpty(list) && list.size() > 1) {
    // faultProductDRO.setFixedPrice(GlobalConsts.NO);
    // logger.info("===============================1前台产品对应的后台产品不止一个，不满足一口价,showProduct={},faultProductDRO={}", showProductId,
    // faultProductDRO);
    // return faultProductDRO;
    // }
    // //后台产品id
    // Integer productId = list.get(0).getProductId();
    // //价格表
    // Integer tariffId = getDefaultTarrId(channelId, keepType, productId);
    //
    // //价格
    // ProductTariffGroupItemPriceVo vo = productFaultItemService.findDefaultItemByProductId(productId, keepType, tariffId);
    // if (Objects.isNull(vo)) {
    // faultProductDRO.setFixedPrice(GlobalConsts.NO);
    // logger.info("==================1价格数据为空，无法计算,productId={},keepType={},tariffId={},faultProductDRO={}", productId, keepType, tariffId,
    // faultProductDRO);
    // return faultProductDRO;
    // }
    // //查询渠道折扣
    // Float channelDiscont = getChannelDiscount(channelId, keepType);
    // Float cityRatio = getCityRatio(channelId, cityId, productId, keepType);
    // //默认价格不考虑品牌
    // vo.setBrandLimit(ProductDict.RADIO_FALSE);
    // ItemPriceDTO dto = getParamDTO(vo, channelDiscont, cityRatio, null);
    // Integer price = calPrice(dto);
    //
    //
    // // 故障价格表的服务项
    // faultProductDRO.setItemId(vo.getItemId());
    // faultProductDRO.setFixedPrice(GlobalConsts.YES);
    // faultProductDRO.setPayType(servCityPrice.getPayType());
    // faultProductDRO.setPriceDiscount(servCityPrice.getPriceDiscount());
    // faultProductDRO.setMutexMode(vo.getMutexMode());
    //
    //// ServItemPrice servItemPrice = servItemPriceService.getStandardPriceByItemIdAndStandardId(servServiceItem.getItemId(), standardId);
    //// // 前期规避价格问题，将两个价格加起来，后期会删掉
    //// if (Objects.nonNull(servItemPrice.getPrice()) && Objects.nonNull(servItemPrice.getPartPrice())) {
    //// servItemPrice.setPrice(servItemPrice.getPrice() + servItemPrice.getPartPrice());
    //// }
    //// if (Objects.isNull(servItemPrice.getPrice()) && Objects.nonNull(servItemPrice.getPartPrice())) {
    //// servItemPrice.setPrice(servItemPrice.getPartPrice());
    //// }
    //
    // // 计算价格城市价
    //// int cityPrice = this.cityPrice(servServiceItem, servItemPrice.getPrice(), cityId, channelId);
    // faultProductDRO.setPrice(price);
    // if (servCityPrice.getPriceDiscount() == 2) {
    // int pricePrice = (int) (price * 0.9);
    // faultProductDRO.setPricePrice(pricePrice);
    // }
    // return faultProductDRO;
    // }
    //
    // logger.debug("=======================================channelPriceCityList is not null==================");
    // ChannelPriceCity channelPriceCity = channelPriceCityList.get(0);
    // if (Objects.equals(channelPriceCity.getType(), GlobalConsts.YES)) {
    // faultProductDRO.setFixedPrice(GlobalConsts.NO);
    // logger.info("channelPriceCity.getType()==GlobalConsts.YES,一口价为否，dto={}", faultProductDRO);
    // translateWashProduct(faultProductDRO, list, keepType, channelId, cityId);
    // return faultProductDRO;
    // }
    //
    // ChannelPrice channelPrice = channelPriceService.findByKey(channelPriceCity.getChannelPriceId());
    // // 是否设置定金
    // if (Objects.equals(channelPrice.getDepositStatus(), GlobalConsts.YES)) {
    // ChannelPriceServ channelPriceServ = channelPriceServService.findByChannelPriceIdAndServCategId(channelPrice.getChannelPriceId(),
    // servProduct.getServCategId());
    // if (Objects.nonNull(channelPriceServ) && NumberUtil.isPositiveInteger(channelPrice.getDeposit())) {
    // faultProductDRO.setEarnestPrice(channelPrice.getDeposit());
    // }
    // }
    //
    //// ServServiceItemQuery serviceItemQuery = new ServServiceItemQuery();
    //// serviceItemQuery.setStatus(GlobalConsts.YES);
    //// serviceItemQuery.setGroupType(type);
    //// serviceItemQuery.setProductId(productId);
    //// serviceItemQuery.setStandardId(standardId);
    //// serviceItemQuery.setFixedPrice(GlobalConsts.YES);
    //// serviceItemQuery.setDefaultItem(GlobalConsts.YES);
    //// List<ServServiceItem> servServiceItemList = servServiceItemService.listByQuery(serviceItemQuery);
    //// if (Objects.isNull(vo)) {
    //// faultProductDRO.setFixedPrice(GlobalConsts.NO);
    //// return faultProductDRO;
    //// }
    //// ServServiceItem servServiceItem = servServiceItemList.get(ProductDict.ZERO);
    // //不支持一口价
    // if (!CollectionUtils.isEmpty(list) && list.size() > 1) {
    // faultProductDRO.setFixedPrice(GlobalConsts.NO);
    // logger.info("===============================2前台产品对应的后台产品不止一个，不满足一口价,showProduct={},faultProductDRO={}", showProductId,
    // faultProductDRO);
    // return faultProductDRO;
    // }
    // //后台产品id
    // Integer productId = list.get(0).getProductId();
    // //价格表
    // Integer tariffId = getDefaultTarrId(channelId, keepType, productId);
    //
    // //价格
    // ProductTariffGroupItemPriceVo vo = productFaultItemService.findDefaultItemByProductId(productId, keepType, tariffId);
    // if (Objects.isNull(vo)) {
    // faultProductDRO.setFixedPrice(GlobalConsts.NO);
    // logger.info("2价格数据为空，无法计算,productId={},keepType={},tariffId={},faultProductDRO={}", productId, keepType, tariffId, faultProductDRO);
    // return faultProductDRO;
    // }
    // //查询渠道折扣
    // Float channelDiscont = getChannelDiscount(channelId, keepType);
    // Float cityRatio = getCityRatio(channelId, cityId, productId, keepType);
    // //默认价格不考虑品牌
    // vo.setBrandLimit(ProductDict.RADIO_FALSE);
    // ItemPriceDTO dto = getParamDTO(vo, channelDiscont, cityRatio, null);
    // Integer price = calPrice(dto);
    //
    // faultProductDRO.setItemId(vo.getItemId());
    // faultProductDRO.setFixedPrice(GlobalConsts.YES);
    // faultProductDRO.setPayType(channelPrice.getPayType());
    // faultProductDRO.setPriceDiscount(channelPrice.getPriceDiscount());
    // faultProductDRO.setMutexMode(vo.getMutexMode());
    //// ServItemPrice servItemPrice = servItemPriceService.getStandardPriceByItemIdAndStandardId(servServiceItem.getItemId(), standardId);
    //// // 前期规避价格问题，将两个价格加起来，后期会删掉
    //// if (Objects.nonNull(servItemPrice.getPrice()) && Objects.nonNull(servItemPrice.getPartPrice())) {
    //// servItemPrice.setPrice(servItemPrice.getPrice() + servItemPrice.getPartPrice());
    //// }
    //// if (Objects.isNull(servItemPrice.getPrice()) && Objects.nonNull(servItemPrice.getPartPrice())) {
    //// servItemPrice.setPrice(servItemPrice.getPartPrice());
    //// }
    ////
    //// // 计算价格城市价
    //// int cityPrice = this.cityPrice(servServiceItem, servItemPrice.getPrice(), cityId, channelId);
    // faultProductDRO.setPrice(price);
    // if (channelPrice.getPriceDiscount() == 2) {
    // int pricePrice = (int) (price * 0.9);
    // faultProductDRO.setPricePrice(pricePrice);
    // }
    // logger.info("========================faultProductDRO last return dto={}", faultProductDRO);
    // return faultProductDRO;
    //
    // }

    // @Override
    // public Integer getDefaultPrice(Integer channelId, Integer cityId, Integer showProductId, Integer keepType) {
    // ServProductRelationQuery query = new ServProductRelationQuery();
    // query.setShowProductId(showProductId);
    // List<ServProductRelation> list = servProductRelationService.listByQuery(query);
    // if (!CollectionUtils.isEmpty(list) && list.size() == 1) {
    // Integer productId = list.get(0).getProductId();
    // Integer tariffId = getDefaultTarrId(channelId, keepType, productId);
    // ProductTariffGroupItemPriceVo vo = productFaultItemService.findDefaultItemByProductId(productId, keepType, tariffId);
    // logger.debug("getDefaultPrice vo = {}", vo);
    // if (null != vo) {
    // //查询渠道折扣
    // Float channelDiscont = getChannelDiscount(channelId, keepType);
    // Float cityRatio = getCityRatio(channelId, cityId, productId, keepType);
    // //默认价格不考虑品牌
    // vo.setBrandLimit(ProductDict.RADIO_FALSE);
    // ItemPriceDTO dto = getParamDTO(vo, channelDiscont, cityRatio, null);
    // return calPrice(dto);
    // }
    // }
    // return null;
    // }

    // @Override
    // public List<ProductFaultItemDRO> listByProductIdAndItemIds(ProductFaultItemDIO productFaultItemDIO) {
    // //查询渠道是否配置了故障价格表
    // Integer tariffId = getDefaultTarrId(productFaultItemDIO.getChannelId(), productFaultItemDIO.getKeepType(),
    // productFaultItemDIO.getProductId());
    // ProductTariffGroupItemQuery query = new ProductTariffGroupItemQuery();
    // query.setProductId(productFaultItemDIO.getProductId());
    // query.setItemIds(productFaultItemDIO.getItemIds());
    // query.setTariffId(tariffId);
    // query.setKeepType(productFaultItemDIO.getKeepType());
    // List<ProductTariffGroupItemVo> items = productFaultItemService.listByProductIdAndItemIds(query);
    // //渠道折扣
    // Float channelDiscont = getChannelDiscount(productFaultItemDIO.getChannelId(), productFaultItemDIO.getKeepType());
    // //城市系数
    // Float cityRatio = getCityRatio(productFaultItemDIO.getChannelId(), productFaultItemDIO.getCityId(),
    // productFaultItemDIO.getProductId(), productFaultItemDIO.getKeepType());
    // //品牌系数(在前台产品上面，需要根据后台产品查询前台产品)
    //// ServProductRelation servProductRelation = servProductRelationService.findByProductId(productFaultItemDIO.getProductId());
    // Float brandRatio = getBrandRatio(productFaultItemDIO.getBrandId(), productFaultItemDIO.getProductId(),
    // productFaultItemDIO.getKeepType());
    // logger.info("===============channelDiscont ={},cityRatio = {},brandRatio = {}", channelDiscont, cityRatio, brandRatio);
    // //计算价格
    // for (ProductTariffGroupItemVo vo : items) {
    // ItemPriceDTO dto = getParamDTO(vo, channelDiscont, cityRatio, brandRatio);
    // calPriceDetail(dto, vo);
    //// Integer price = calPrice(dto);
    //// vo.setPrice(price);
    //// if (dto.getStaticPrice() == 0 || vo.getPartRatio() == null) {
    //// vo.setPartPrice(null);
    //// vo.setServicePrice(null);
    //// } else {
    //// //配件包干费比例
    //// BigDecimal partRatioPercent = new BigDecimal(Double.valueOf(vo.getPartRatio()) / ProductDict.HUNDRED).setScale(2,
    // BigDecimal.ROUND_HALF_UP);
    //// //销售价
    //// BigDecimal priceBig = new BigDecimal(price);
    //// //配件包干费，需要对小鼠部分进行向下取整
    //// BigDecimal partPrice = priceBig.multiply(partRatioPercent);
    //// Integer partPriceInt = partPrice.intValue() / 100 * 100;
    //// vo.setPartPrice(partPriceInt);
    //// vo.setServicePrice(priceBig.subtract(new BigDecimal(partPriceInt)).subtract(new BigDecimal(dto.getStaticPrice())).intValue());
    //// }
    // }
    // List<ProductFaultItemDRO> list = transVoListToDroList(items);
    // return list;
    // }

    // @Override
    // public List<ProductFaultItemDRO> listByProductIdAndFaultCategId(ProductFaultItemDIO productFaultItemDIO) {
    // //查询渠道是否配置了故障价格表
    // Integer tariffId = getDefaultTarrId(productFaultItemDIO.getChannelId(), productFaultItemDIO.getKeepType(),
    // productFaultItemDIO.getProductId());
    // ProductTariffGroupItemQuery query = new ProductTariffGroupItemQuery();
    // query.setProductId(productFaultItemDIO.getProductId());
    // query.setCategId(productFaultItemDIO.getCategId());
    // query.setKeepType(productFaultItemDIO.getKeepType());
    // query.setTariffId(tariffId);
    // List<ProductTariffGroupItemVo> items = productFaultItemService.listByProductIdAndFaultCategId(query);
    // //渠道折扣
    // Float channelDiscont = getChannelDiscount(productFaultItemDIO.getChannelId(), productFaultItemDIO.getKeepType());
    // //城市系数
    // Float cityRatio = getCityRatio(productFaultItemDIO.getChannelId(), productFaultItemDIO.getCityId(),
    // productFaultItemDIO.getProductId(), productFaultItemDIO.getKeepType());
    // //品牌系数(在前台产品上面，需要根据后台产品查询前台产品)
    // //ServProductRelation servProductRelation = servProductRelationService.findByProductId(productFaultItemDIO.getProductId());
    // Float brandRatio = getBrandRatio(productFaultItemDIO.getBrandId(), productFaultItemDIO.getProductId(),
    // productFaultItemDIO.getKeepType());
    // logger.info("===============channelDiscont ={},cityRatio = {},brandRatio = {}", channelDiscont, cityRatio, brandRatio);
    // //计算价格
    // for (ProductTariffGroupItemVo vo : items) {
    // ItemPriceDTO dto = getParamDTO(vo, channelDiscont, cityRatio, brandRatio);
    // calPriceDetail(dto, vo);
    // }
    // List<ProductFaultItemDRO> list = transVoListToDroList(items);
    // return list;
    // }

    // @Override
    // public List<ShowProductFaultItemDRO> listByShowProductIdAndFaultCategId(ShowProductFaultItemDIO showProductFaultItemDIO) {
    // //查询渠道是否配置了故障价格表
    // Integer tariffId = getDefaultTarrIdForProducts(showProductFaultItemDIO.getChannelId(), showProductFaultItemDIO.getKeepType());
    // ProductTariffGroupItemQuery productQuery = new ProductTariffGroupItemQuery();
    // List<Integer> productIds = new ArrayList<>();
    // if (showProductFaultItemDIO.getItemIds() != null && showProductFaultItemDIO.getItemIds().size() > 0) {
    // productQuery.setKeepType(showProductFaultItemDIO.getKeepType());
    // productQuery.setTariffId(tariffId);
    // productQuery.setItemIds(showProductFaultItemDIO.getItemIds());
    // productQuery.setShowProductId(showProductFaultItemDIO.getShowProductId());
    // List<ProductTariffGroupItemVo> productFaultItemVos = productFaultItemService.listByShowProductIdAndItemIds(productQuery);
    // productIds = groupAndFilterByStep(showProductFaultItemDIO, productFaultItemVos);
    // }
    //
    // List<ShowProductFaultItemDRO> list = new ArrayList<>();
    // ProductTariffGroupItemQuery query = new ProductTariffGroupItemQuery();
    // query.setCategId(showProductFaultItemDIO.getCategId());
    // query.setKeepType(showProductFaultItemDIO.getKeepType());
    // query.setTariffId(tariffId);
    // query.setShowProductId(showProductFaultItemDIO.getShowProductId());
    // query.setProductIds(productIds);
    // List<ProductTariffGroupItemVo> items = productFaultItemService.listByShowProductIdAndFaultCategId(query);
    // if (!CollectionUtils.isEmpty(items)) {
    // BeanCopier copier = BeanCopier.create(ProductTariffGroupItemVo.class, ShowProductFaultItemDRO.class, false);
    // list = items.stream().map(e -> {
    // ShowProductFaultItemDRO dro = new ShowProductFaultItemDRO();
    // copier.copy(e, dro, null);
    // return dro;
    // }).collect(Collectors.toList());
    // }
    // return list;
    // }

    // @Override
    // public List<ProductFaultItemDRO> listByCategId(Integer channelId, Integer cityId, Integer categId, Integer keepType) {
    // //查询渠道是否配置了故障价格表
    // Integer tariffId = getDefaultTarrIdForProducts(channelId, keepType);
    // ProductTariffGroupItemQuery query = new ProductTariffGroupItemQuery();
    // query.setProductCategId(categId);
    // query.setKeepType(keepType);
    // query.setTariffId(tariffId);
    // query.setCategIds(Arrays.asList(FaultCategoryEnum.NORMAL_FAULT.getCode(), FaultCategoryEnum.SPECIAL_FAULT.getCode()));
    // List<ProductTariffGroupItemVo> items = productFaultItemService.listByCategId(query);
    // List<ProductFaultItemDRO> list = transVoListToDroList(items);
    // return list;
    // }
    //
    // @Override
    // public List<ProductFaultDRO> listProductPriceByCategId(ProductFaultDIO productFaultDIO) {
    // List<ProductTariffGroupItemVo> productFaultDROS = filterList(productFaultDIO);
    //
    // return calcPriceByCityRatioAndBrandRatio(productFaultDIO, productFaultDROS);
    // }

    // @Override
    // public List<ProductFaultItemDRO> listByShowProductId(Integer channelId, Integer cityId, Integer productId, Integer keepType) {
    // //查询渠道是否配置了故障价格表
    // Integer tariffId = getDefaultTarrIdForProducts(channelId, keepType);
    // ProductTariffGroupItemQuery query = new ProductTariffGroupItemQuery();
    // query.setProductId(productId);
    // query.setKeepType(keepType);
    // query.setTariffId(tariffId);
    // List<ProductTariffGroupItemPriceVo> items = productFaultItemService.listByShowProductId(query);
    // if (items != null && items.size() > 0 && tariffId != null) {
    // items = filterByTariffId(items, tariffId, keepType);
    // }
    //
    // List<ProductFaultItemDRO> list = combineShowProduct(items, channelId, cityId, keepType, null, productId);
    // return list;
    // }
    //
    //
    // @Override
    // public List<ProductFaultItemDRO> listByProductId(FaultItemPriceDIO dio) {
    // //查询渠道是否配置了故障价格表
    // ServProduct servProduct = servProductService.findByKey(dio.getProductId());
    // if (servProduct == null) {
    // logger.error("产品不存在,{}", dio.getProductId());
    // return Collections.EMPTY_LIST;
    // }
    // //前台产品需要合并价格表
    // boolean isNeedToCombine = servProduct.getShowType().equals(ProductDict.EC_PRODUCT_TYPE);
    // //后台产品Id
    // Integer showProductId = null;
    // Integer tariffId = null;
    // if (isNeedToCombine) {
    // tariffId = getDefaultTarrIdForProducts(dio.getChannelId(), dio.getKeepType());
    // showProductId = servProduct.getProductId();
    // } else {
    // tariffId = getDefaultTarrId(dio.getChannelId(), dio.getKeepType(), dio.getProductId());
    // ServProductRelation relation = servProductRelationService.findByProductId(dio.getProductId());
    // showProductId = relation.getShowProductId();
    // }
    //
    // ProductTariffGroupItemQuery query = new ProductTariffGroupItemQuery();
    // if (isNeedToCombine) {
    // query.setShowProductId(dio.getProductId());
    // } else {
    // query.setProductId(dio.getProductId());
    // }
    // query.setKeepType(dio.getKeepType());
    // query.setTariffId(tariffId);
    // List<ProductTariffGroupItemPriceVo> items = productFaultItemService.listByProductId(query);
    // if (isNeedToCombine) {
    // if (items != null && items.size() > 0 && tariffId != null) {
    // items = filterByTariffId(items, tariffId, dio.getKeepType());
    // }
    // }
    //
    // //前台产品需要合并价格表
    // return combineShowProduct(items, dio.getChannelId(), dio.getCityId(), dio.getKeepType(), dio.getBrandId(), showProductId);
    // }

    // @Override
    // @SuppressWarnings("Duplicates")
    // public ShowProductPageDRO listPageByQuery(ShowProductDIO productFaultItemDIO) {
    // //查询渠道是否配置了故障价格表
    // Integer tariffId = getDefaultTarrIdForProducts(productFaultItemDIO.getChannelId(), productFaultItemDIO.getKeepType());
    // ProductTariffGroupItemSimpleQuery productFaultItemSimpleQuery = new ProductTariffGroupItemSimpleQuery();
    // BeanCopier copierQuery = BeanCopier.create(ShowProductDIO.class, ProductTariffGroupItemSimpleQuery.class, false);
    // copierQuery.copy(productFaultItemDIO, productFaultItemSimpleQuery, null);
    // if (productFaultItemDIO.getPageNum() != null && productFaultItemDIO.getPageNum() > 0) {
    // productFaultItemSimpleQuery.setPageIndex(productFaultItemDIO.getPageNum());
    // }
    // if (productFaultItemDIO.getPageSize() != null && productFaultItemDIO.getPageSize() > 0) {
    // productFaultItemSimpleQuery.setPageSize(productFaultItemDIO.getPageSize());
    // }
    // productFaultItemSimpleQuery.setTariffId(tariffId);
    // List<ServProductVO> servProductVOList = productFaultItemService.listPageByShowCategId(productFaultItemSimpleQuery);
    // List<ShowProductDRO> list = new ArrayList<>();
    // if (!CollectionUtils.isEmpty(servProductVOList)) {
    // BeanCopier copier = BeanCopier.create(ServProductVO.class, ShowProductDRO.class, false);
    // list = servProductVOList.stream().map(e -> {
    // ShowProductDRO dro = new ShowProductDRO();
    // copier.copy(e, dro, null);
    // return dro;
    // }).collect(Collectors.toList());
    // }
    // ShowProductPageDRO showProductPageDRO = new ShowProductPageDRO();
    // showProductPageDRO.setTotalCount(productFaultItemSimpleQuery.getTotalCount());
    // showProductPageDRO.setProductList(list);
    // return showProductPageDRO;
    // }
    //
    // @Override
    // public List<ProductFaultDRO> listProductPriceByShowProductId(ProductFaultDIO productFaultDIO) {
    // List<ProductTariffGroupItemVo> productFaultDROS = filterFaultList(productFaultDIO);
    //
    // return calcPriceByCityRatioAndBrandRatio(productFaultDIO, productFaultDROS);
    // }
    //
    // @Override
    // public List<FaultItemPriceDRO> listPriceSplitItemPriceByProductId(FaultItemPriceDIO faultItemPriceDIO) {
    // //渠道折扣
    // Float channelDiscont = getChannelDiscount(faultItemPriceDIO.getChannelId(), faultItemPriceDIO.getKeepType());
    // //城市系数
    // Float cityRatio = getCityRatio(faultItemPriceDIO.getChannelId(), faultItemPriceDIO.getCityId(), faultItemPriceDIO.getProductId(),
    // faultItemPriceDIO.getKeepType());
    // //品牌系数(在前台产品上面，需要根据后台产品查询前台产品)
    // Float brandRatio = null;
    // if (faultItemPriceDIO.getBrandId() != null) {
    //// ServProductRelation relation = servProductRelationService.findByProductId(faultItemPriceDIO.getProductId());
    // brandRatio = getBrandRatio(faultItemPriceDIO.getBrandId(), faultItemPriceDIO.getProductId(), faultItemPriceDIO.getKeepType());
    // }
    // //价格表
    // Integer tariffId = getDefaultTarrId(faultItemPriceDIO.getChannelId(), faultItemPriceDIO.getKeepType(),
    // faultItemPriceDIO.getProductId());
    // ProductTariffGroupItemQuery query = new ProductTariffGroupItemQuery();
    // query.setTariffId(tariffId);
    // query.setProductId(faultItemPriceDIO.getProductId());
    // query.setKeepType(faultItemPriceDIO.getKeepType());
    // query.setPriceStandard(GlobalConsts.YES);
    // List<ProductTariffGroupItemVo> items = productFaultItemService.listItemPriceByProductId(query);
    // List<FaultItemPriceDRO> retList = transVoToOrderDro(items, channelDiscont, cityRatio, brandRatio);
    // return retList;
    // }
    //
    // @Override
    // public List<FaultItemPriceDRO> listDefautItemPriceByProductId(FaultItemPriceDIO faultItemPriceDIO) {
    // //渠道折扣
    // Float channelDiscont = getChannelDiscount(faultItemPriceDIO.getChannelId(), faultItemPriceDIO.getKeepType());
    // //城市系数
    // Float cityRatio = getCityRatio(faultItemPriceDIO.getChannelId(), faultItemPriceDIO.getCityId(), faultItemPriceDIO.getProductId(),
    // faultItemPriceDIO.getKeepType());
    // //品牌系数(在前台产品上面，需要根据后台产品查询前台产品)
    // Float brandRatio = null;
    // if (faultItemPriceDIO.getBrandId() != null) {
    //// ServProductRelation relation = servProductRelationService.findByProductId(faultItemPriceDIO.getProductId());
    // brandRatio = getBrandRatio(faultItemPriceDIO.getBrandId(), faultItemPriceDIO.getProductId(), faultItemPriceDIO.getKeepType());
    // }
    // //价格表
    // Integer tariffId = getDefaultTarrId(faultItemPriceDIO.getChannelId(), faultItemPriceDIO.getKeepType(),
    // faultItemPriceDIO.getProductId());
    // ProductTariffGroupItemQuery query = new ProductTariffGroupItemQuery();
    // query.setTariffId(tariffId);
    // query.setProductId(faultItemPriceDIO.getProductId());
    // query.setKeepType(faultItemPriceDIO.getKeepType());
    // query.setPriceStandard(GlobalConsts.NO);
    // List<ProductTariffGroupItemVo> items = productFaultItemService.listItemPriceByProductId(query);
    // List<FaultItemPriceDRO> retList = transVoToOrderDro(items, channelDiscont, cityRatio, brandRatio);
    // return retList;
    // }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Integer batchAddEdit(String mcStaffName, List<ProductTariffGroupItem> productFaultItems) {
        Date now = DateUtil.getNow();
        Integer productId = 0;
        Integer tariffId = 0;
        if (productFaultItems != null && productFaultItems.size() > 0) {
            productId = productFaultItems.get(0).getProductId();
            tariffId = productFaultItems.get(0).getTariffId();
        }

        ProductTariffGroupItemQuery query = new ProductTariffGroupItemQuery();
        query.setProductId(productId);
        query.setTariffId(tariffId);
        List<ProductTariffGroupItemVo> items = productFaultItemService.listByQuery(query);
        List<Integer> dbIds = items.stream().map(item -> item.getItemId()).collect(Collectors.toList());
        List<Integer> realIds = productFaultItems.stream().map(e -> e.getItemId()).collect(Collectors.toList());
        List<Integer> deleteIds = dbIds.stream().filter(item -> !realIds.contains(item)).collect(Collectors.toList());

        productFaultItemService.deleteByProductIdAndTariffId(productId, tariffId);

        if (deleteIds != null && deleteIds.size() > 0) {
            productFaultItemCityPriceService.deleteByProductIdAndTarifIdAndItemIds(productId, tariffId, deleteIds);
        }

        for (ProductTariffGroupItem productFaultItem : productFaultItems) {
            productFaultItem.setCreater(mcStaffName);
            productFaultItem.setCreateTime(now);
            productFaultItem.setUpdater(mcStaffName);
            productFaultItem.setUpdateTime(now);
            productFaultItemService.insert(productFaultItem);
        }

        return productId;
    }

    // private List<FaultItemPriceDRO> transVoToOrderDro(List<ProductTariffGroupItemVo> items, Float channelDiscont, Float cityRatio, Float
    // brandRatio) {
    // if (CollectionUtils.isEmpty(items)) {
    // return Collections.EMPTY_LIST;
    // }
    // List<FaultItemPriceDRO> retList = new ArrayList<>();
    // BeanCopier copier = BeanCopier.create(ProductTariffGroupItemVo.class, FaultItemPriceDRO.class, false);
    // for (ProductTariffGroupItemVo vo : items) {
    // FaultItemPriceDRO dro = new FaultItemPriceDRO();
    // ItemPriceDTO dto = getParamDTO(vo, channelDiscont, cityRatio, brandRatio);
    // calPriceDetail(dto, vo);
    // //销售价
    //// Integer price = calPrice(dto);
    // copier.copy(vo, dro, null);
    //// dro.setPrice(price);
    //// if (dto.getStaticPrice() == 0 || vo.getPartRatio() == null) {
    //// dro.setPartPrice(null);
    //// dro.setServicePrice(null);
    //// } else {
    //// //配件包干费比例
    //// BigDecimal partRatioPercent = new BigDecimal(Double.valueOf(vo.getPartRatio()) / ProductDict.HUNDRED).setScale(2,
    // BigDecimal.ROUND_HALF_UP);
    //// //销售价
    //// BigDecimal priceBig = new BigDecimal(price);
    //// //配件包干费，需要对小鼠部分进行向下取整
    //// BigDecimal partPrice = priceBig.multiply(partRatioPercent);
    //// Integer partPriceInt = partPrice.intValue() / 100 * 100;
    //// dro.setPartPrice(partPriceInt);
    //// dro.setServicePrice(priceBig.subtract(new BigDecimal(partPriceInt)).subtract(new BigDecimal(dto.getStaticPrice())).intValue());
    //// }
    // retList.add(dro);
    // }
    // return retList;
    // }
    //
    // private void calPriceDetail(ItemPriceDTO dto, BaseTariffGroupItemPriceVo vo) {
    // Integer price = calPrice(dto);
    // vo.setPrice(price);
    // if (dto.getStaticPrice() == 0 || vo.getPartRatio() == null) {
    // vo.setPartPrice(null);
    // vo.setServicePrice(null);
    // } else {
    // //配件包干费比例
    // BigDecimal partRatioPercent = new BigDecimal(Double.valueOf(vo.getPartRatio()) / ProductDict.HUNDRED).setScale(2,
    // BigDecimal.ROUND_HALF_UP);
    // //销售价
    // BigDecimal priceBig = new BigDecimal(price);
    // //配件包干费，需要对小鼠部分进行向下取整
    // BigDecimal partPrice = priceBig.multiply(partRatioPercent);
    // Integer partPriceInt = partPrice.intValue() / 100 * 100;
    // vo.setPartPrice(partPriceInt);
    // vo.setServicePrice(priceBig.subtract(new BigDecimal(partPriceInt)).subtract(new BigDecimal(dto.getStaticPrice())).intValue());
    // }
    // }
    //
    //
    // private List<ProductFaultDRO> calcPriceByCityRatioAndBrandRatio(ProductFaultDIO productFaultDIO, List<ProductTariffGroupItemVo>
    // productFaultItemVos) {
    // List<ProductFaultDRO> productFaultDROS = new ArrayList<>();
    // //排除不合符要求的数据重新计算价格
    // if (!CollectionUtils.isEmpty(productFaultItemVos)) {
    // //渠道折扣
    // Float channelDiscont = getChannelDiscount(productFaultDIO.getChannelId(), productFaultDIO.getKeepType());
    // //品牌系数(在前台产品上面，需要根据后台产品查询前台产品)
    //// Float brandRatio = getBrandRatio(productFaultDIO.getBrandId(), productFaultDIO.getShowProductId(), productFaultDIO.getKeepType());
    // Map<String, ProductFaultDRO> droMap = new HashMap<>();
    // Map<Integer, List<BrandFactorRatioVo>> brandRatioMap = new HashMap<>();
    // BeanCopier copier = BeanCopier.create(ProductTariffGroupItemVo.class, ProductFaultItemDRO.class, false);
    // for (ProductTariffGroupItemVo pro : productFaultItemVos) {
    // //城市系数
    // Float cityRatio = getCityRatio(productFaultDIO.getChannelId(), productFaultDIO.getCityId(), pro.getProductId(),
    // productFaultDIO.getKeepType());
    // //品牌放到最后一步，这个时候是没办法确定品牌的，根据后台产品查询出品牌，然后计算品牌系数
    // List<BrandFactorRatioVo> brandFactorRatioVos = brandRatioMap.get(pro.getProductId());
    // if (null == brandFactorRatioVos) {
    // brandFactorRatioVos = brandRatioBService.listByProductId(pro.getProductId());
    // brandRatioMap.put(pro.getProductId(), brandFactorRatioVos);
    // }
    // //没有品牌，品牌系数不存在
    // if (CollectionUtils.isEmpty(brandFactorRatioVos)) {
    // calcate(null, pro, channelDiscont, cityRatio, productFaultDROS, droMap, copier);
    // } else {
    // BeanCopier temCopier = BeanCopier.create(ProductTariffGroupItemVo.class, ProductTariffGroupItemVo.class, false);
    // for (BrandFactorRatioVo vo : brandFactorRatioVos) {
    // ProductTariffGroupItemVo ps = new ProductTariffGroupItemVo();
    // temCopier.copy(pro, ps, null);
    // calcate(vo, ps, channelDiscont, cityRatio, productFaultDROS, droMap, copier);
    // }
    // }
    //
    //
    //// Float brandRatio = getBrandRatio(productFaultDIO.getBrandId(), pro.getProductId(), productFaultDIO.getKeepType());
    ////
    //// ItemPriceDTO dto = getParamDTO(pro, channelDiscont, cityRatio, brandRatio);
    ////// Integer price = calPrice(dto);
    //// calPriceDetail(dto, pro);
    //// ProductFaultDRO productFaultDRO = droMap.get(pro.getProductId());
    //// ProductFaultItemDRO itemDRO = new ProductFaultItemDRO();
    //// if (productFaultDRO == null) {
    //// productFaultDRO = new ProductFaultDRO();
    //// productFaultDRO.setProductId(pro.getProductId());
    //// productFaultDRO.setName(pro.getProductName());
    //// productFaultDRO.setTariffName(pro.getTariffName());
    //// List<ProductFaultItemDRO> list = new ArrayList<>();
    //// copier.copy(pro, itemDRO, null);
    ////// itemDRO.setPrice(price);
    //// list.add(itemDRO);
    //// productFaultDRO.setFaultItemDROS(list);
    //// droMap.put(pro.getProductId(), productFaultDRO);
    //// productFaultDROS.add(productFaultDRO);
    //// } else {
    //// copier.copy(pro, itemDRO, null);
    ////// itemDRO.setPrice(price);
    //// productFaultDRO.getFaultItemDROS().add(itemDRO);
    //// }
    // }
    // }
    // return productFaultDROS;
    // }

    // private void calcate(BrandFactorRatioVo vo, ProductTariffGroupItemVo pro, Float channelDiscont,
    // Float cityRatio, List<ProductFaultDRO> productFaultDROS,
    // Map<String, ProductFaultDRO> droMap, BeanCopier copier) {
    // Float brandRatio = null;
    // String key = pro.getProductId() + "_";
    // if (null != vo) {
    // brandRatio = new BigDecimal(vo.getRatio()).floatValue();
    // key = key + vo.getBrandId();
    // } else {
    // vo = new BrandFactorRatioVo();
    // }
    //
    // ItemPriceDTO dto = getParamDTO(pro, channelDiscont, cityRatio, brandRatio);
    // calPriceDetail(dto, pro);
    // ProductFaultDRO productFaultDRO = droMap.get(key);
    // ProductFaultItemDRO itemDRO = new ProductFaultItemDRO();
    // if (productFaultDRO == null) {
    // productFaultDRO = new ProductFaultDRO();
    // productFaultDRO.setProductId(pro.getProductId());
    // productFaultDRO.setName(pro.getProductName());
    // productFaultDRO.setTariffName(pro.getTariffName());
    // productFaultDRO.setBrandId(vo.getBrandId());
    // productFaultDRO.setBrandName(vo.getBrandName());
    // List<ProductFaultItemDRO> list = new ArrayList<>();
    // copier.copy(pro, itemDRO, null);
    // list.add(itemDRO);
    // productFaultDRO.setFaultItemDROS(list);
    // droMap.put(key, productFaultDRO);
    // productFaultDROS.add(productFaultDRO);
    // } else {
    // copier.copy(pro, itemDRO, null);
    // productFaultDRO.getFaultItemDROS().add(itemDRO);
    // }
    // }
    //
    //
    // /**
    // * 功能描述 :前台产品合并价格表
    // *
    // * @param items
    // * @param channelId
    // * @param cityId
    // * @param keepType
    // * @return java.util.List<com.zmn.plat.common.dto.product.service.item.ProductFaultItemDRO>
    // * @author tanbiao
    // * @since 2019/12/12
    // * @modifier
    // */
    // private List<ProductFaultItemDRO> combineShowProduct(List<ProductTariffGroupItemPriceVo> items, Integer channelId, Integer cityId,
    // Integer keepType, Integer brandId, Integer showProductId) {
    // List<ProductFaultItemDRO> list = new ArrayList<>();
    // if (!CollectionUtils.isEmpty(items)) {
    // //查询渠道折扣
    // Float channelDiscont = getChannelDiscount(channelId, keepType);
    // boolean isNeedBrandRadio = brandId != null && showProductId != null;
    // //需要根据产品属性查询属性值进行拼装
    // Map<Integer, String> productNameMap = new HashMap<>();
    // for (ProductTariffGroupItemPriceVo vo : items) {
    // //查询城市系数
    // Float cityRatio = getCityRatio(channelId, cityId, vo.getProductId(), keepType);
    // Float brandRatio = null;
    // //设置价格，不考虑品牌系数
    // if (isNeedBrandRadio) {
    // logger.debug("============================品牌系数不为空，进行品牌系数计算,showProductId={}", showProductId);
    // brandRatio = getBrandRatio(brandId, vo.getProductId(), keepType);
    // }
    //// vo.setBrandLimit(ProductDict.RADIO_FALSE);
    // ItemPriceDTO dto = getParamDTO(vo, channelDiscont, cityRatio, brandRatio);
    // calPriceDetail(dto, vo);
    //// Integer price = calPrice(dto);
    //// vo.setPrice(price);
    // //设置名称
    // if (StringUtil.isNotBlank(productNameMap.get(vo.getProductId()))) {
    // vo.setProductName(vo.getCatgegTwoName() + productNameMap.get(vo.getProductId()));
    // } else {
    // List<Integer> attrIds = new ArrayList<>();
    // if (StringUtil.isNotBlank(vo.getSequence()) && vo.getSequence().indexOf("&") != -1) {
    // String[] seqArray = vo.getSequence().split(",");
    // for (String seq : seqArray) {
    // if (StringUtil.isNotBlank(seq) && seq.indexOf("&") != -1) {
    // String[] enumIdArray = seq.split("&");
    // if (enumIdArray.length > 1 && !Objects.equals(enumIdArray[0], enumIdArray[1])) {
    // attrIds.add(Integer.valueOf(enumIdArray[1]));
    // }
    // }
    // }
    // }
    // List<BaseCategoryAttributeEnum> enumList = new ArrayList<>();
    // if (!CollectionUtils.isEmpty(attrIds)) {
    // enumList = baseCategoryAttributeEnumService.listByKeys(attrIds);
    // }
    // StringBuilder stringBuilder = new StringBuilder();
    // if (CollectionUtils.isEmpty(enumList)) {
    // vo.setProductName(vo.getCatgegTwoName());
    // } else {
    // enumList.forEach(e -> {
    // stringBuilder.append(e.getEnumValue()).append(",");
    // });
    // if (stringBuilder.length() > 0) {
    // stringBuilder.deleteCharAt(stringBuilder.length() - 1);
    // }
    // vo.setProductName(vo.getCatgegTwoName() + stringBuilder.toString());
    // }
    // productNameMap.put(vo.getProductId(), stringBuilder.toString());
    // }
    // list.add(transVoToDro(vo));
    // }
    // }
    // return list;
    // }
    //
    //
    // private List<ProductFaultItemDRO> transVoListToDroList(List<ProductTariffGroupItemVo> items) {
    // List<ProductFaultItemDRO> list = new ArrayList<>();
    // if (!CollectionUtils.isEmpty(items)) {
    // BeanCopier copier = BeanCopier.create(ProductTariffGroupItemVo.class, ProductFaultItemDRO.class, false);
    // list = items.stream().map(e -> {
    // ProductFaultItemDRO dro = new ProductFaultItemDRO();
    // copier.copy(e, dro, null);
    // return dro;
    // }).collect(Collectors.toList());
    // }
    // return list;
    // }

    // private ProductFaultItemDRO transVoToDro(ProductTariffGroupItemPriceVo vo) {
    // BeanCopier copier = BeanCopier.create(ProductTariffGroupItemPriceVo.class, ProductFaultItemDRO.class, false);
    // ProductFaultItemDRO faultItemDRO = new ProductFaultItemDRO();
    // copier.copy(vo, faultItemDRO, null);
    // return faultItemDRO;
    // }

    // private Float getChannelDiscount(Integer channelId, Integer keepType) {
    // ChannelCityPriceRatio channelCityPriceRatio =
    // channelCityPriceRatioService.findByChannelIdAndRatioTypeAndCityAndCategAndKeepType(channelId,
    // ChannelCityRatioTypeEnum.DISCOUNTRATIO.getCode(), null, null, null , null, keepType);
    // Float channelDisconut = null;
    // if (null != channelCityPriceRatio) {
    // Double ratio = channelCityPriceRatio.getRatio();
    // if (null != ratio) {
    // channelDisconut = new BigDecimal(ratio).floatValue();
    // }
    // }
    // logger.debug("=====================getChannelDiscount channelDisconut = {},channelId={},keepType={}", channelDisconut, channelId,
    // keepType);
    // return channelDisconut;
    // }

    // private Float getCityRatio(Integer channelId, Integer cityId, Integer productId, Integer keepType) {
    // // 查询城市系数
    // Float ratio = channelCityPriceRatioBService.findRatioByChannelIdAndCityId(channelId, cityId,
    // productId, keepType);
    // logger.debug("=====================getCityRatio ratio = {},channelId={},keepType={},cityId={}，productId={}", ratio, channelId,
    // keepType, cityId, productId);
    // return ratio;
    // }
    //
    // private Float getBrandRatio(Integer brandId, Integer productId, Integer keepType) {
    // logger.debug("========================getBrandRatio params is {},{},{}", brandId, productId, keepType);
    // //品牌系数(在前台产品上面，需要根据后台产品查询前台产品)
    // if (brandId == null || productId == null) {
    // logger.debug("======================getBrandRatio brandId or showProductId为空");
    // return null;
    // }
    //
    // BrandFactorDRO brandFactorDRO = brandRatioBService.getByBrandIdAndProductIdAndBizTypeAndPriceType(brandId, productId, keepType,
    // BaseBrandPriceTypeEnum.PRICE.getCode());
    // logger.debug("=======================getCityRatio brandFactorDRO = {}", brandFactorDRO);
    // if (brandFactorDRO == null || brandFactorDRO.getRatio() == null) {
    // logger.debug("======================brandFactorDRO or radio为空");
    // return null;
    // }
    //
    // Float brandRatio = new BigDecimal(brandFactorDRO.getRatio()).floatValue();
    // return brandRatio;
    // }

    /**
     * 针对后台产品ID唯一时，获取渠道配置的故障价格表ID，如果产品价格表被禁用 则走默认价格表
     *
     * @param channelId
     * @param keepType
     * @param productId
     * @return
     */
    // private Integer getDefaultTarrId(Integer channelId, Integer keepType, Integer productId) {
    // logger.debug("==================getDefaultTarrId params is {},{},{},{}", channelId, keepType, productId);
    // //查询渠道是否配置了故障价格表
    // Integer tariffId = null;
    // ChannelFaultPriceVO channelFaultPrice = channelTariffService.findByChannelIdAndKeepTypeAndTariffType(channelId, keepType,
    // ProductDict.TRIFF_TYPE_TARIFF);
    // if (null != channelFaultPrice) {
    // tariffId = channelFaultPrice.getTariffId();
    // if (tariffId != null) {
    // ServiceTariff faultTariff = faultTariffService.findByKey(tariffId);
    // if (faultTariff == null || faultTariff.getStatus() == null || faultTariff.getStatus() == GlobalConsts.NO) {
    // return null;
    // }
    //
    // ProductTariffQuery productFaultTariffQuery = new ProductTariffQuery();
    // productFaultTariffQuery.setProductId(productId);
    // productFaultTariffQuery.setTariffId(tariffId);
    // List<ProductTariffVO> productFaultTariffVOS = productFaultTariffService.listByQuery(productFaultTariffQuery);
    // ProductTariffVO productFaultTariffVO = new ProductTariffVO();
    // if (productFaultTariffVOS != null && productFaultTariffVOS.size() > 0) {
    // productFaultTariffVO = productFaultTariffVOS.get(0);
    // }
    // logger.info("=====================productFaultTariffVO 参数为：{}", productFaultTariffVO);
    // if (productFaultTariffVO == null || productFaultTariffVO.getStatus() == null || productFaultTariffVO.getStatus() == GlobalConsts.NO)
    // {
    // tariffId = null;
    // }
    // }
    // }
    // logger.info("=====================getDefaultTarrId return tariffId={},channelId={},keepType={},productId={}", tariffId, channelId,
    // keepType, productId);
    // return tariffId;
    // }

    /**
     * 针对后台产品ID不唯一时，获取默认渠道配置的默认价格表
     *
     * @param channelId
     * @param keepType
     * @return
     */
    // private Integer getDefaultTarrIdForProducts(Integer channelId, Integer keepType) {
    // //查询渠道是否配置了故障价格表
    // Integer tariffId = null;
    // ChannelFaultPriceVO channelFaultPrice = channelTariffService.findByChannelIdAndKeepTypeAndTariffType(channelId, keepType,
    // ProductDict.TRIFF_TYPE_TARIFF);
    // if (null != channelFaultPrice) {
    // tariffId = channelFaultPrice.getTariffId();
    // }
    // logger.info("getDefaultTarrIdForProducts return tariffId={},channelId={},keepType={}", tariffId, channelId, keepType);
    // return tariffId;
    // }

    /**
     * 功能描述 ：计算销售价格：每一次的系数计算不能小于不变的部分
     *
     * @param faultPriceDTO：费用计算DTO
     * @return java.lang.Integer
     * @author tanbiao
     * @since 2019/12/13
     * @modifier
     */
    // private Integer calPrice(ItemPriceDTO faultPriceDTO) {
    // logger.info("==========================calPrice params is {}", faultPriceDTO);
    // Integer staticPrice = faultPriceDTO.getStaticPrice();
    // Integer partRatio = faultPriceDTO.getPartRatio();
    // Integer price = faultPriceDTO.getPrice();
    // Float channelDiscont = faultPriceDTO.getChannelDiscont();
    // Float cityRatio = faultPriceDTO.getCityRatio();
    // Float brandRatio = faultPriceDTO.getBrandRatio();
    // boolean cityLimit = faultPriceDTO.isCityLimit();
    // boolean brandLimit = faultPriceDTO.isBrandLimit();
    // //不区分明细的情况下不考虑最小价格
    // boolean isLimitByPrice = staticPrice == null || staticPrice.compareTo(0) == 0;
    // if (NumberUtil.isPositiveInteger(price)) {
    // //最低价格
    // Integer minPrice = getMinPrice(price, partRatio, staticPrice);
    // //渠道折扣
    // Integer channelDisCountPrice = CityPriceUtil.calcCityPrice(price, channelDiscont);
    // if (!isLimitByPrice && channelDisCountPrice.compareTo(minPrice) < 0) {
    // channelDisCountPrice = minPrice;
    // }
    // logger.debug("渠道折扣价格={}", channelDisCountPrice);
    // // 计算价格城市价(受城市系数影响的时候计算价格)
    // Integer cityPrice = channelDisCountPrice;
    // if (cityLimit) {
    // cityPrice = CityPriceUtil.calcCityPrice(channelDisCountPrice, cityRatio);
    // if (!isLimitByPrice && cityPrice.compareTo(minPrice) < 0) {
    // cityPrice = minPrice;
    // }
    // logger.debug("查询城市价格={}", cityPrice);
    // }
    // // 品牌系数
    // Integer brandPrice = cityPrice;
    // if (brandLimit) {
    // brandPrice = CityPriceUtil.calcCityPrice(cityPrice, brandRatio);
    // if (!isLimitByPrice && brandPrice.compareTo(minPrice) < 0) {
    // brandPrice = minPrice;
    // }
    // logger.debug("品牌系数价格={}", brandPrice);
    // }
    // price = brandPrice;
    // logger.debug("最终价格={}", price);
    // }
    // return price;
    // }

    /**
     * 功能描述 :最低价格实际上就是技术服务费为0(技术服务费=总价-交通费工时费-总价*配件包干费比例) 遵循689规则
     *
     * @param price
     * @param partRatio
     * @param staticPrice
     * @return java.math.BigDecimal
     * @author tanbiao
     * @since 2019/12/17
     * @modifier
     */
    // private Integer getMinPrice(Integer price, Integer partRatio, Integer staticPrice) {
    // //销售价
    // BigDecimal priceBig = new BigDecimal(price);
    // if (partRatio == null || staticPrice == null || staticPrice == 0) {
    // logger.debug("======================getMinPrice 不存在配件费比例，返回原始价格{}====================", priceBig);
    // return price;
    // }
    // //交通费工时费
    // BigDecimal staticPriceBig = new BigDecimal(staticPrice);
    // //配件包干费比例,不用689
    // BigDecimal partRatioPercent = new BigDecimal(Double.valueOf(partRatio) / ProductDict.HUNDRED).setScale(2, BigDecimal.ROUND_HALF_UP);
    // //配件包干费
    // BigDecimal partPriceBig = priceBig.multiply(partRatioPercent);
    // Integer minPrice = staticPriceBig.add(partPriceBig).intValue();
    // Integer finalPrice = CityPriceUtil.calcCityPrice(minPrice, RESULT_RATIO);
    // logger.info("======================getMinPrice return minPrice:{}", finalPrice);
    // //最低销售价进行689操作
    // return finalPrice;
    // }
    //
    // private ItemPriceDTO getParamDTO(BaseTariffGroupItemPriceVo vo, Float channelDiscont, Float cityRatio, Float brandRatio) {
    // ItemPriceDTO dto = new ItemPriceDTO();
    // dto.setPrice(vo.getPrice());
    // if (vo.getHourFee() == null || vo.getTrafficFee() == null) {
    // // 临时修改
    // dto.setStaticPrice(0);
    // } else {
    // dto.setStaticPrice(vo.getHourFee() + vo.getTrafficFee());
    // }
    // dto.setPartRatio(vo.getPartRatio());
    // dto.setChannelDiscont(channelDiscont);
    // dto.setCityRatio(cityRatio);
    // dto.setBrandRatio(brandRatio);
    // dto.setCityLimit(vo.getCityLimit() != null && vo.getCityLimit() == ProductDict.RADIO_TRUE);
    // dto.setBrandLimit(vo.getBrandLimit() != null && vo.getBrandLimit() == ProductDict.RADIO_TRUE);
    // logger.debug("getParamDTO return ==============:{}", dto);
    // return dto;
    // }

    // private void setName(FaultProductDRO faultProductDRO) {
    // BaseCategory baseCategory = baseCategoryService.findByKey(faultProductDRO.getCategOneId());
    // faultProductDRO.setCategOneName(baseCategory.getName());
    //
    // ServCategory servCategory = servCategoryService.findByKey(faultProductDRO.getServCategId());
    // faultProductDRO.setServCategName(Objects.equals(faultProductDRO.getShowType(), ProductConsts.ERP_PRODUCT_TYPE) ?
    // servCategory.getName() :
    // servCategory.getShowName());
    //
    // if (!NumberUtil.isNullOrZero(faultProductDRO.getFicoCtegId())) {
    // FicoCategory ficoCategory = ficoCategoryService.findByKey(faultProductDRO.getFicoCtegId());
    // faultProductDRO.setFicoCtegName(ficoCategory.getName());
    // }
    //
    // baseCategory = baseCategoryService.findByKey(faultProductDRO.getCategId());
    // if (baseCategory != null) {
    // faultProductDRO.setCategName(baseCategory.getName());
    // }
    // }

    // @SuppressWarnings("Duplicates")
    // private List<ProductTariffGroupItemVo> filterList(ProductFaultDIO productFaultDIO) {
    // //查询渠道是否配置了故障价格表
    // Integer tariffId = getDefaultTarrIdForProducts(productFaultDIO.getChannelId(), productFaultDIO.getKeepType());
    // ProductTariffGroupItemQuery query = new ProductTariffGroupItemQuery();
    // query.setItemIds(productFaultDIO.getItemIds());
    // query.setTariffId(tariffId);
    // query.setServCategId(productFaultDIO.getServCategId());
    // query.setCategId(productFaultDIO.getCategId());
    // query.setKeepType(productFaultDIO.getKeepType());
    // List<ProductTariffGroupItemVo> items = productFaultItemService.listProductPriceByCategId(query);
    //
    // return groupAndFilterData(productFaultDIO, items);
    // }
    //
    //
    // @SuppressWarnings("Duplicates")
    // private List<ProductTariffGroupItemVo> filterFaultList(ProductFaultDIO productFaultDIO) {
    // //查询渠道是否配置了故障价格表
    // Integer tariffId = getDefaultTarrIdForProducts(productFaultDIO.getChannelId(), productFaultDIO.getKeepType());
    // ProductTariffGroupItemQuery query = new ProductTariffGroupItemQuery();
    // query.setItemIds(productFaultDIO.getItemIds());
    // query.setTariffId(tariffId);
    // query.setShowProductId(productFaultDIO.getShowProductId());
    // query.setKeepType(productFaultDIO.getKeepType());
    // List<ProductTariffGroupItemVo> items = productFaultItemService.listProductPriceByShowProductId(query);
    // List<ProductTariffGroupItemVo> itemVos = groupAndFilterData(productFaultDIO, items);
    // return itemVos;
    // }

    /**
     * 根据所选itemIds一层一层筛选符合条件的后台产品Id
     *
     * @param showProductFaultItemDIO
     * @param items
     * @return
     */
    // private List<Integer> groupAndFilterByStep(ShowProductFaultItemDIO showProductFaultItemDIO, List<ProductTariffGroupItemVo> items) {
    // //按照产品进行归类，并返回有相同items个数的数据
    // Map<Integer, List<ProductTariffGroupItemVo>> droMap = new HashMap<>();
    // if (!CollectionUtils.isEmpty(items)) {
    // for (ProductTariffGroupItemVo vo : items) {
    // List<ProductTariffGroupItemVo> itemVos = droMap.get(vo.getProductId());
    // if (null == itemVos) {
    // itemVos = new ArrayList<>();
    // itemVos.add(vo);
    // droMap.put(vo.getProductId(), itemVos);
    // } else {
    // itemVos.add(vo);
    // }
    // }
    // }
    // //排除不符合选项的后台产品（itemid集合必须被查询结果集包含）
    // List<ProductTariffGroupItemVo> productFaultDROS = new ArrayList<>();
    // List<Integer> productIds = new ArrayList<>();
    // if (!droMap.isEmpty()) {
    // droMap.forEach((k, v) -> {
    // List<Integer> innerItemIds = v.stream().map(ProductTariffGroupItemVo::getItemId).distinct().collect(Collectors.toList());
    // if (innerItemIds.containsAll(showProductFaultItemDIO.getItemIds())) {
    // productIds.add(k);
    // }
    // });
    // }
    //
    // return productIds;
    // }
    //
    // private List<ProductTariffGroupItemVo> groupAndFilterData(ProductFaultDIO productFaultDIO, List<ProductTariffGroupItemVo> items) {
    // //按照产品进行归类，并返回有相同items个数的数据
    // Map<Integer, List<ProductTariffGroupItemVo>> droMap = new HashMap<>();
    // if (!CollectionUtils.isEmpty(items)) {
    // for (ProductTariffGroupItemVo vo : items) {
    // List<ProductTariffGroupItemVo> itemVos = droMap.get(vo.getProductId());
    // if (null == itemVos) {
    // itemVos = new ArrayList<>();
    // itemVos.add(vo);
    // droMap.put(vo.getProductId(), itemVos);
    // } else {
    // itemVos.add(vo);
    // }
    // }
    // }
    // //排除不符合选项的数据（itemid个数必须和传递的数据一致）
    // List<ProductTariffGroupItemVo> productFaultDROS = new ArrayList<>();
    // int itemSize = productFaultDIO.getItemIds().size();
    // if (!droMap.isEmpty()) {
    // droMap.forEach((k, v) -> {
    // if (v.size() == itemSize) {
    // productFaultDROS.addAll(v);
    // }
    // });
    // }
    //
    // return productFaultDROS;
    // }

    // private List<ProductTariffGroupItemPriceVo> filterByTariffId(List<ProductTariffGroupItemPriceVo> items, Integer tariffId, Integer
    // keepType) {
    // List<Integer> productIds = items.stream().map(ProductTariffGroupItemPriceVo::getProductId).distinct().collect(Collectors.toList());
    // List<Integer> tariffIds = items.stream().map(ProductTariffGroupItemPriceVo::getTariffId).distinct().collect(Collectors.toList());
    // if (tariffIds != null && tariffIds.size() == 1) {
    // return items;
    // }
    // Map<String, List<ProductTariffGroupItemPriceVo>> map =
    // items.stream().collect(Collectors.groupingBy(ProductTariffGroupItemPriceVo::getProductIdUnionTariffIdKey));
    // ServiceTariffQuery faultTariffQuery = new ServiceTariffQuery();
    // faultTariffQuery.setKeepType(keepType);
    // faultTariffQuery.setGeneral(2);
    // List<ServiceTariff> faultTariffs = faultTariffService.listByQuery(faultTariffQuery);
    // Integer defaultTariffId = 0;
    // if (faultTariffs != null && faultTariffs.size() > 0) {
    // defaultTariffId = faultTariffs.get(0).getTariffId();
    // }
    //
    // List<ProductTariffGroupItemPriceVo> result = new ArrayList<>();
    // for (Integer productId : productIds) {
    // String defaultTariffKey = productId + "-" + defaultTariffId;
    // String tariffKey = productId + "-" + tariffId;
    // if (map.get(tariffKey) != null && map.get(tariffKey).size() > 0) {
    // for (ProductTariffGroupItemPriceVo productFaultItemPriceVo : map.get(tariffKey)) {
    // result.add(productFaultItemPriceVo);
    // }
    // } else if (map.get(defaultTariffKey) != null && map.get(defaultTariffKey).size() > 0) {
    // for (ProductTariffGroupItemPriceVo productFaultItemPriceVo : map.get(defaultTariffKey)) {
    // result.add(productFaultItemPriceVo);
    // }
    // }
    // }
    //
    // return result;
    // }

    // private void translateWashProduct(FaultProductDRO faultProductDRO, List<ServProductRelation> list, Integer keepType, Integer
    // channelId, Integer cityId) {
    // //清洗类产品单独处理，在不支持一口价的情况下返回价格
    // if (Objects.equals(faultProductDRO.getServCategId(), ProductConsts.CATEG_CLEANING)) {
    // logger.info("==========translateWashProduct 清洗类产品单独处理.....faultProductDRO={},keepType={},channelId={},cityId={}", faultProductDRO,
    // keepType, channelId, cityId);
    // //不支持一口价
    // if (!CollectionUtils.isEmpty(list) && list.size() > 1) {
    // faultProductDRO.setFixedPrice(GlobalConsts.NO);
    // logger.info("=========translateWashProduct 前台产品对应的后台产品不止一个，不满足一口价,faultProductDRO={}", faultProductDRO);
    // return;
    // }
    // Integer productId = list.get(0).getProductId();
    // Integer tariffId = getDefaultTarrId(channelId, keepType, productId);
    // ProductTariffGroupItemPriceVo vo = productFaultItemService.findDefaultItemByProductId(productId, keepType, tariffId);
    // if (Objects.isNull(vo)) {
    // faultProductDRO.setFixedPrice(GlobalConsts.NO);
    // logger.info("translateWashProduct 价格数据为空，无法计算,productId={},keepType={},tariffId={},faultProductDRO={}", productId, keepType,
    // tariffId, faultProductDRO);
    // return;
    // }
    // //查询渠道折扣
    // Float channelDiscont = getChannelDiscount(channelId, keepType);
    // Float cityRatio = getCityRatio(channelId, cityId, productId, keepType);
    // //默认价格不考虑品牌
    // vo.setBrandLimit(ProductDict.RADIO_FALSE);
    // ItemPriceDTO dto = getParamDTO(vo, channelDiscont, cityRatio, null);
    // Integer price = calPrice(dto);
    //
    // faultProductDRO.setItemId(vo.getItemId());
    // faultProductDRO.setFixedPrice(GlobalConsts.NO);
    // faultProductDRO.setMutexMode(vo.getMutexMode());
    // faultProductDRO.setPrice(price);
    // }
    // }

}
